home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 11 / Cream of the Crop 11-1.iso / games / ted5.zip / TED5-3.C < prev    next >
C/C++ Source or Header  |  1995-10-20  |  44KB  |  2,034 lines
  1. ////////////////////////////////////////////////////
  2. ////////////////////////////////////////////////////
  3. //
  4. // TED5-3
  5. //
  6. ////////////////////////////////////////////////////
  7. ////////////////////////////////////////////////////
  8. #include "ted5.h"
  9. #pragma hdrstop
  10.  
  11. int xms1;
  12. extern int tics;
  13.  
  14. ////////////////////////////////////////////////////
  15. //
  16. // MAP SCROLLING
  17. //
  18. ////////////////////////////////////////////////////
  19. void CheckMapScroll(void)
  20. {
  21.  //
  22.  // LEFT
  23.  //
  24.  if (keydown[0x4b])    // left arrow
  25.    {
  26.     int i,j,imax,jmax,tilesmoved;
  27.  
  28.     tics=biostime(0,0);
  29.  
  30.     if (xbase)
  31.     {
  32.      EraseFloatPaste();
  33.  
  34.      if (keydown[0x1d])    // CTRL-KEY
  35.      {
  36.       tilesmoved=screenw;
  37.       if (keydown[0x38]) // ALT-KEY
  38.       {
  39.        xbase=0;
  40.        DrawMap();
  41.        return;
  42.       }
  43.      }
  44.      else
  45.        switch(videomode)
  46.        {
  47.     case CGA:
  48.     case EGA1:
  49.     case VGA:
  50.       tilesmoved=1;
  51.       break;
  52.     case EGA2:
  53.       tilesmoved=2;
  54.        }
  55.  
  56.      if (xbase<tilesmoved)
  57.        tilesmoved=xbase;
  58.      xbase-=tilesmoved;
  59.  
  60.      MouseHide();
  61.      if (tilesmoved<screenw)
  62.        CopyScreen(0,8,infomaxw-(tilesmoved<<(tsize-1)),screenh<<(tsize+2),tilesmoved<<(tsize-1),8);
  63.  
  64.      jmax=screenh;
  65.      if (jmax>mapheight)
  66.        jmax=mapheight;
  67.  
  68.      for (i=0;i<tilesmoved;i++)
  69.        for (j=0;j<jmax;j++)
  70.        {
  71.     unsigned tilet,tilem,tilei,loc;
  72.  
  73.     loc=(ybase+j)*mapwidth+xbase+i;
  74.  
  75.     tilet=*(MapBkgnd+loc);
  76.     tilem=*(MapFrgnd+loc)+tilenum;
  77.     tilei=*(MapInfoPl+loc)+tilenum;
  78.  
  79.     CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
  80.     if (GridMode)
  81.       Overlay(tsize);
  82.     DrawTile(i<<(tsize-1),j*(4<<tsize)+8,tsize);
  83.     CheckInfoValues(i,j,tilei);
  84.     CheckSelectEdges(i+xbase,j+ybase,i,j);
  85.        }
  86.  
  87.      px+=tilesmoved;
  88.      DrawFloatPaste();
  89.      MouseShow();
  90.      if (keydown[0x36] || keydown[0x1d])
  91.        while(keydown[0x4b]);
  92.     }
  93.    }
  94.  else
  95.  //
  96.  // RIGHT
  97.  //
  98.  if (keydown[0x4d])    // right arrow
  99.    {
  100.     int i,j,imax,jmax,tilesmoved;
  101.  
  102.     tics=biostime(0,0);
  103.  
  104.     if (xbase+screenw<mapwidth)
  105.     {
  106.      EraseFloatPaste();
  107.  
  108.      if (keydown[0x1d])    // CTRL-KEY
  109.      {
  110.       tilesmoved=screenw;
  111.       if (keydown[0x38]) // ALT-KEY
  112.       {
  113.        xbase=mapwidth-screenw;
  114.        DrawMap();
  115.        return;
  116.       }
  117.      }
  118.      else
  119.        switch(videomode)
  120.        {
  121.     case CGA:
  122.     case EGA1:
  123.     case VGA:
  124.       tilesmoved=1;
  125.       break;
  126.     case EGA2:
  127.       tilesmoved=2;
  128.        }
  129.  
  130.  
  131.      if (xbase+screenw+tilesmoved>=mapwidth)
  132.        tilesmoved=mapwidth-screenw-xbase;
  133.      xbase+=tilesmoved;
  134.  
  135.      MouseHide();
  136.      if (tilesmoved<screenw)
  137.        CopyScreen(tilesmoved<<(tsize-1),8,infomaxw-(tilesmoved<<(tsize-1)),screenh<<(tsize+2),0,8);
  138.  
  139.      jmax=screenh;
  140.      if (jmax>mapheight)
  141.        jmax=mapheight;
  142.  
  143.      for (i=0;i<tilesmoved;i++)
  144.        for (j=0;j<jmax;j++)
  145.        {
  146.     unsigned tilet,tilem,tilei,loc;
  147.  
  148.     loc=(ybase+j)*mapwidth+xbase+screenw-tilesmoved+i;
  149.  
  150.     tilet=*(MapBkgnd+loc);
  151.     tilem=*(MapFrgnd+loc)+tilenum;
  152.     tilei=*(MapInfoPl+loc)+tilenum;
  153.  
  154.     CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
  155.     if (GridMode)
  156.       Overlay(tsize);
  157.     DrawTile(infomaxw-((tilesmoved-i)<<(tsize-1)),j*(4<<tsize)+8,tsize);
  158.     CheckInfoValues(screenw-tilesmoved+i,j,tilei);
  159.     CheckSelectEdges(screenw-tilesmoved+i+xbase,j+ybase,i+screenw-tilesmoved,j);
  160.        }
  161.  
  162.      px+=tilesmoved;
  163.      DrawFloatPaste();
  164.      MouseShow();
  165.      if (keydown[0x36] || keydown[0x1d])
  166.        while(keydown[0x4d]);
  167.     }
  168.    }
  169.  
  170.  //
  171.  // UP
  172.  //
  173.  if (keydown[0x48])    // up arrow
  174.    {
  175.     int i,j,imax,jmax,tilesmoved;
  176.  
  177.     tics=biostime(0,0);
  178.  
  179.     if (ybase)
  180.     {
  181.      EraseFloatPaste();
  182.  
  183.      if (keydown[0x1d])    // CTRL-KEY
  184.      {
  185.       tilesmoved=screenh;
  186.       if (keydown[0x38]) // ALT-KEY
  187.       {
  188.        ybase=0;
  189.        DrawMap();
  190.        return;
  191.       }
  192.      }
  193.      else
  194.        switch(videomode)
  195.        {
  196.     case CGA:
  197.     case EGA1:
  198.     case VGA:
  199.       tilesmoved=1;
  200.       break;
  201.     case EGA2:
  202.       tilesmoved=2;
  203.        }
  204.  
  205.      if (ybase<tilesmoved)
  206.        tilesmoved=ybase;
  207.      ybase-=tilesmoved;
  208.  
  209.      MouseHide();
  210.      if (tilesmoved<screenh)
  211.        CopyScreen(0,8,infomaxw,(screenh-tilesmoved)<<(tsize+2),0,8+(tilesmoved<<(tsize+2)));
  212.  
  213.      imax=screenw;
  214.      if (imax>mapwidth)
  215.        imax=mapwidth;
  216.  
  217.      for (j=0;j<tilesmoved;j++)
  218.        for (i=0;i<imax;i++)
  219.        {
  220.     unsigned tilet,tilem,tilei,loc;
  221.  
  222.     loc=(ybase+j)*mapwidth+xbase+i;
  223.  
  224.     tilet=*(MapBkgnd+loc);
  225.     tilem=*(MapFrgnd+loc)+tilenum;
  226.     tilei=*(MapInfoPl+loc)+tilenum;
  227.  
  228.     CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
  229.     if (GridMode)
  230.       Overlay(tsize);
  231.     DrawTile(i<<(tsize-1),8+(j<<(tsize+2)),tsize);
  232.     CheckInfoValues(i,j,tilei);
  233.     CheckSelectEdges(i+xbase,j+ybase,i,j);
  234.        }
  235.  
  236.      py+=tilesmoved;
  237.      DrawFloatPaste();
  238.      MouseShow();
  239.      if (keydown[0x36] || keydown[0x1d])
  240.        while(keydown[0x48]);
  241.     }
  242.    }
  243.  else
  244.  //
  245.  // DOWN
  246.  //
  247.  if (keydown[0x50])    // down arrow
  248.    {
  249.     int i,j,imax,jmax,tilesmoved;
  250.  
  251.     tics=biostime(0,0);
  252.  
  253.     if (ybase+screenh<mapheight)
  254.     {
  255.      EraseFloatPaste();
  256.  
  257.      if (keydown[0x1d])    // CTRL-KEY
  258.      {
  259.       tilesmoved=screenh;
  260.       if (keydown[0x38]) // ALT-KEY
  261.       {
  262.        ybase=mapheight-screenh;
  263.        DrawMap();
  264.        return;
  265.       }
  266.      }
  267.      else
  268.        switch(videomode)
  269.        {
  270.     case CGA:
  271.     case EGA1:
  272.     case VGA:
  273.       tilesmoved=1;
  274.       break;
  275.     case EGA2:
  276.       tilesmoved=2;
  277.        }
  278.  
  279.      if (ybase+screenh+tilesmoved>=mapheight)
  280.        tilesmoved=mapheight-screenh-ybase;
  281.      ybase+=tilesmoved;
  282.  
  283.      MouseHide();
  284.      if (tilesmoved<screenh)
  285.        CopyScreen(0,8+(tilesmoved<<(tsize+2)),infomaxw,(screenh-tilesmoved)<<(tsize+2),0,8);
  286.  
  287.      imax=screenw;
  288.      if (imax>mapwidth)
  289.        imax=mapwidth;
  290.  
  291.      for (j=0;j<tilesmoved;j++)
  292.        for (i=0;i<imax;i++)
  293.        {
  294.     unsigned tilet,tilem,tilei,loc;
  295.  
  296.     loc=(ybase+j+screenh-tilesmoved)*mapwidth+xbase+i;
  297.  
  298.     tilet=*(MapBkgnd+loc);
  299.     tilem=*(MapFrgnd+loc)+tilenum;
  300.     tilei=*(MapInfoPl+loc)+tilenum;
  301.  
  302.     CombineTiles(tilet*viewton-BkgndColor*(!viewton),tilem*viewmon,tilei*viewion,tsize);
  303.     if (GridMode)
  304.       Overlay(tsize);
  305.     DrawTile(i<<(tsize-1),8+((screenh-tilesmoved+j)<<(tsize+2)),tsize);
  306.     CheckInfoValues(i,screenh-tilesmoved+j,tilei);
  307.     CheckSelectEdges(i+xbase,screenh-tilesmoved+j+ybase,i,j+screenh-tilesmoved);
  308.        }
  309.  
  310.  
  311.      py+=tilesmoved;
  312.      DrawFloatPaste();
  313.      MouseShow();
  314.      if (keydown[0x36] || keydown[0x1d])
  315.        while(keydown[0x50]);
  316.     }
  317.    }
  318. }
  319.  
  320.  
  321. ////////////////////////////////////////////////////
  322. //
  323. // Copy a screen section to another, mode independent
  324. //
  325. ////////////////////////////////////////////////////
  326. void CopyScreen(int srcx,int srcy,int width,int height,int destx,int desty)
  327. {
  328.  switch(videomode)
  329.  {
  330.   case CGA: CopyCGA(srcx,srcy,width,height,destx,desty); break;
  331.   case EGA1:
  332.   case EGA2:outport(SCindex,0x0f00 | SCmapmask);CopyEGA(srcx,srcy,width,height,destx,desty); break;
  333.   case VGA: CopyVGA(srcx,srcy,width,height,destx,desty);
  334.  }
  335. }
  336.  
  337.  
  338. ////////////////////////////////////////////////////
  339. //
  340. // See if either of the Select edges are visible on the map
  341. // Draw them if so
  342. //
  343. ////////////////////////////////////////////////////
  344. void CheckSelectEdges(int x,int y,int i,int j)
  345. {
  346.  int temp;
  347.  
  348.  if (SelX2<SelX1)
  349.    {
  350.     temp=SelX1;
  351.     SelX1=SelX2;
  352.     SelX2=temp;
  353.    }
  354.  if (SelY2<SelY1)
  355.    {
  356.     temp=SelY1;
  357.     SelY1=SelY2;
  358.     SelY2=temp;
  359.    }
  360.  
  361.  if (y==SelY2 && x==SelX2)
  362.    {
  363.     switch(tsize)
  364.     {
  365.      case 1: drawchar(i,j+1,8);
  366.          break;
  367.      case 2: drawchar(i*2+1,j*2+2,8);
  368.          drawchar(i*2+1,j*2+1,5);
  369.          drawchar(i*2,j*2+2,7);
  370.          break;
  371.      case 3: drawchar(i*4+3,j*4+4,8);
  372.  
  373.          drawchar(i*4+3,j*4+3,5);
  374.          drawchar(i*4+3,j*4+2,5);
  375.          drawchar(i*4+3,j*4+1,5);
  376.  
  377.          drawchar(i*4+2,j*4+4,7);
  378.          drawchar(i*4+1,j*4+4,7);
  379.          drawchar(i*4,j*4+4,7);
  380.          break;
  381.     }
  382.    }
  383.  
  384.  if (y==SelY1 && x==SelX1)
  385.    {
  386.     switch(tsize)
  387.     {
  388.      case 1: drawchar(i,j+1,1);
  389.          break;
  390.      case 2: drawchar(i*2,j*2+1,1);
  391.          drawchar(i*2+1,j*2+1,2);
  392.          drawchar(i*2,j*2+2,4);
  393.          break;
  394.      case 3: drawchar(i*4,j*4+1,1);
  395.  
  396.          drawchar(i*4+1,j*4+1,2);
  397.          drawchar(i*4+2,j*4+1,2);
  398.          drawchar(i*4+3,j*4+1,2);
  399.  
  400.          drawchar(i*4,j*4+2,4);
  401.          drawchar(i*4,j*4+3,4);
  402.          drawchar(i*4,j*4+4,4);
  403.          break;
  404.     }
  405.    }
  406.  
  407.  if (y==SelY2 && x==SelX1)
  408.    {
  409.     switch(tsize)
  410.     {
  411.      case 1: drawchar(i,j+1,6);
  412.          break;
  413.      case 2: drawchar(i*2  ,j*2+2,6);
  414.          drawchar(i*2+1,j*2+2,7);
  415.          drawchar(i*2  ,j*2+1,4);
  416.          break;
  417.      case 3: drawchar(i*4,j*4+4,6);
  418.  
  419.          drawchar(i*4+1,j*4+4,7);
  420.          drawchar(i*4+2,j*4+4,7);
  421.          drawchar(i*4+3,j*4+4,7);
  422.  
  423.          drawchar(i*4,j*4+1,4);
  424.          drawchar(i*4,j*4+2,4);
  425.          drawchar(i*4,j*4+3,4);
  426.          break;
  427.     }
  428.    }
  429.  
  430.  if (y==SelY1 && x==SelX2)
  431.    {
  432.     switch(tsize)
  433.     {
  434.      case 1: drawchar(i,j+1,3);
  435.          break;
  436.      case 2: drawchar(i*2+1,j*2+1,3);
  437.          drawchar(i*2+1,j*2+2,5);
  438.          drawchar(i*2  ,j*2+1,2);
  439.          break;
  440.      case 3: drawchar(i*4+3,j*4+1,3);
  441.  
  442.          drawchar(i*4+3,j*4+4,5);
  443.          drawchar(i*4+3,j*4+3,5);
  444.          drawchar(i*4+3,j*4+2,5);
  445.  
  446.          drawchar(i*4+2,j*4+4,7);
  447.          drawchar(i*4+1,j*4+4,7);
  448.          drawchar(i*4,j*4+4,7);
  449.          break;
  450.     }
  451.    }
  452.  
  453.  if (y==SelY1 && x>SelX1 && x<SelX2)
  454.    {
  455.     switch(tsize)
  456.     {
  457.      case 3: drawchar(i*4+2,j*4+1,2);
  458.          drawchar(i*4+3,j*4+1,2);
  459.          drawchar(i*4+1,j*4+1,2);
  460.          drawchar(i*4  ,j*4+1,2);
  461.          break;
  462.      case 2: drawchar(i*2+1,j*2+1,2);
  463.          drawchar(i*2  ,j*2+1,2);
  464.          break;
  465.      case 1: drawchar(i,j+1,2);
  466.          break;
  467.     }
  468.    }
  469.  
  470.  if (y==SelY2 && x>SelX1 && x<SelX2)
  471.    {
  472.     switch(tsize)
  473.     {
  474.      case 1: drawchar(i,j+1,7);
  475.          break;
  476.      case 2: drawchar(i*2,j*2+2,7);
  477.          drawchar(i*2+1,j*2+2,7);
  478.          break;
  479.      case 3: drawchar(i*4  ,j*4+4,7);
  480.          drawchar(i*4+1,j*4+4,7);
  481.          drawchar(i*4+2,j*4+4,7);
  482.          drawchar(i*4+3,j*4+4,7);
  483.          break;
  484.     }
  485.    }
  486.  
  487.  if (x==SelX1 && y>SelY1 && y<SelY2)
  488.    {
  489.     switch(tsize)
  490.     {
  491.      case 3: drawchar(i*4,j*4+3,4);
  492.          drawchar(i*4,j*4+4,4);
  493.          drawchar(i*4,j*4+2,4);
  494.          drawchar(i*4,j*4+1,4);
  495.          break;
  496.      case 2: drawchar(i*2,j*2+2,4);
  497.          drawchar(i*2,j*2+1,4);
  498.          break;
  499.      case 1: drawchar(i,j+1,4);
  500.          break;
  501.     }
  502.    }
  503.  
  504.  if (x==SelX2 && y>SelY1 && y<SelY2)
  505.    {
  506.     switch(tsize)
  507.     {
  508.      case 1: drawchar(i,j+1,5);
  509.          break;
  510.      case 2: drawchar(i*2+1,j*2+1,5);
  511.          drawchar(i*2+1,j*2+2,5);
  512.          break;
  513.      case 3: drawchar(i*4+3,j*4+1,5);
  514.          drawchar(i*4+2,j*4+1,5);
  515.          drawchar(i*4+1,j*4+1,5);
  516.          drawchar(i*4  ,j*4+1,5);
  517.     }
  518.    }
  519.  
  520.  
  521. }
  522.  
  523. ////////////////////////////////////////////////////
  524. //
  525. // FLOATING PASTE REGION!
  526. //
  527. ////////////////////////////////////////////////////
  528. void CheckFloatPaste(int mx,int my)
  529. {
  530.  int i,j,maxh,maxw;
  531.  
  532.  
  533.  if (SnapMode && PasteMode && (pixely>=8 || pixely<infoy*8))
  534.    {
  535.     mx=(mx/snapxsize)*snapxsize+snapx;
  536.     my=(my/snapysize)*snapysize+snapy;
  537.  
  538.     if (mx<xbase)
  539.       mx+=snapxsize;
  540.     if (my<ybase)
  541.       my+=snapysize;
  542.     if (mx>=xbase+screenw)
  543.       mx-=snapxsize;
  544.     if (my>=ybase+screenh)
  545.       my-=snapysize;
  546.    }
  547.  
  548.  if (!PasteMode || (px==mx && py==my) || (pixely<8 || pixely>infoy*8))
  549.    return;
  550.  
  551.  if (mx>mapwidth || my>mapheight)
  552.    return;
  553.  
  554.  MouseHide();
  555.  EraseFloatPaste();
  556.  
  557.  //
  558.  // FLOAT IT...
  559.  //
  560.  px=mx;
  561.  py=my;
  562.  
  563.  DrawFloatPaste();
  564.  MouseShow();
  565. }
  566.  
  567.  
  568. ////////////////////////////////////////////////////
  569. //
  570. // DRAW FLOATING PASTE REGION
  571. //
  572. void DrawFloatPaste(void)
  573. {
  574.  int i,j,maxw,maxh;
  575.  
  576.  
  577.  if (px==-1 || py==-1 || !PasteMode)
  578.    return;
  579.  //
  580.  // NOW, DRAW IT IN A NEW LOCATION!
  581.  //
  582.  MouseHide();
  583.  
  584.  
  585.  maxh=TileCopy.h;
  586.  if (py+maxh>mapheight)
  587.    maxh=mapheight-py;
  588.  if (py+maxh-ybase>screenh)
  589.    maxh=screenh-(py-ybase);
  590.  
  591.  maxw=TileCopy.w;
  592.  if (px+maxw>mapwidth)
  593.    maxw=mapwidth-px;
  594.  if (px+maxw-xbase>screenw)
  595.    maxw=screenw-(px-xbase);
  596.  
  597.  switch(TileCopy.MapOrTileSelect)
  598.  {
  599.   case 0: // MAP PASTE DRAW
  600.     for (j=0;j<maxh;j++)
  601.       for (i=0;i<maxw;i++)
  602.     {
  603.      unsigned tilet,tilem,tilei,loc,loc1,oldt,oldm,oldi;
  604.      int theT,theM,theI;
  605.  
  606.      loc=(TileCopy.y+j)*mapwidth+TileCopy.x+i;
  607.      loc1=(py+j)*mapwidth+px+i;
  608.  
  609.      tilet=*(CutBkgnd+loc);
  610.      oldt=MapBkgnd[loc1];
  611.      tilem=*(CutFrgnd+loc)+tilenum;
  612.      if (tilem==tilenum)
  613.        tilem=0;
  614.      oldm=MapFrgnd[loc1]+tilenum;
  615.      tilei=*(CutInfoPl+loc)+tilenum;
  616.      if (tilei==tilenum)
  617.        tilei=0;
  618.      oldi=MapInfoPl[loc1]+tilenum;
  619.  
  620.      theT=(TileCopy.PlanesCopied&BPLANE)?tilet:-BkgndColor;
  621.      if (theT==-BkgndColor && viewton)
  622.        theT=oldt;
  623.      theM=(TileCopy.PlanesCopied&FPLANE)?tilem:0;
  624.      if (!theM && viewmon && !(TileCopy.PlanesCopied&FPLANE && F3_flag))
  625.        theM=oldm;
  626.      theI=(TileCopy.PlanesCopied&IPLANE)?tilei:0;
  627.      if (!theI && viewion && !(TileCopy.PlanesCopied&IPLANE && F3_flag))
  628.        theI=oldi;
  629.  
  630.      CombineTiles(theT,theM,theI,tsize);
  631.      if (GridMode)
  632.        Overlay(tsize);
  633.      DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
  634.     }
  635.     break;
  636.  
  637.   case 1: // TILE PASTE DRAW
  638.     for (j=0;j<maxh;j++)
  639.       for (i=0;i<maxw;i++)
  640.     {
  641.      int val=(j+TileCopy.y)*selectcols+TileCopy.x+i;
  642.      unsigned tilem,tilei,loc;
  643.  
  644.      loc=(py+j)*mapwidth+px+i;
  645.  
  646.      tilem=MapFrgnd[loc]+tilenum;
  647.      tilei=MapInfoPl[loc]+tilenum;
  648.  
  649.      if (XMSlookup[val]!=-1)
  650.        {
  651.         CombineTiles(viewton?val:-BkgndColor,
  652.              viewmon?tilem:0,
  653.              viewion?tilei:0,
  654.              tsize);
  655.         if (GridMode)
  656.           Overlay(tsize);
  657.         DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
  658.        }
  659.     }
  660.     break;
  661.  
  662.   case 2: // MASKED PASTE DRAW
  663.     for (j=0;j<maxh;j++)
  664.       for (i=0;i<maxw;i++)
  665.     {
  666.      int val=(j+TileCopy.y)*selectcols+TileCopy.x+i+tilenum+maxiconrows*selectcols;
  667.      unsigned tilet,tilei,loc;
  668.  
  669.      loc=(py+j)*mapwidth+px+i;
  670.  
  671.      tilet=MapBkgnd[loc];
  672.      tilei=MapInfoPl[loc]+tilenum;
  673.  
  674.      if (XMSlookup[val]!=-1)
  675.        {
  676.         CombineTiles(viewton?tilet:-BkgndColor,
  677.              viewmon?val:0,
  678.              viewion?tilei:0,
  679.              tsize);
  680.         if (GridMode)
  681.           Overlay(tsize);
  682.         DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
  683.        }
  684.     }
  685.  }
  686.  
  687.  MouseShow();
  688. }
  689.  
  690. ////////////////////////////////////////////////////
  691. //
  692. // ERASE FLOATING PASTE REGION
  693. //
  694. void EraseFloatPaste(void)
  695. {
  696.  int maxh,maxw,i,j;
  697.  
  698.  
  699.  if (px==-1 || py==-1 || !PasteMode)
  700.    return;
  701.  
  702.  //
  703.  // ERASE THE FLOATING REGION
  704.  // (PRECLIPPING REGION)
  705.  //
  706.  MouseHide();
  707.  
  708.  maxh=TileCopy.h;
  709.  if (py+maxh>mapheight)
  710.    maxh=mapheight-py;
  711.  if (py+maxh-ybase>screenh)
  712.    maxh=screenh-(py-ybase);
  713.  
  714.  maxw=TileCopy.w;
  715.  if (px+maxw>mapwidth)
  716.    maxw=mapwidth-px;
  717.  if (px+maxw-xbase>screenw)
  718.    maxw=screenw-(px-xbase);
  719.  
  720.  for (j=0;j<maxh;j++)
  721.    for (i=0;i<maxw;i++)
  722.      {
  723.       unsigned tile_t,tile_m,tile_i,loc;
  724.  
  725.       loc=(py+j)*mapwidth+px+i;
  726.  
  727.       tile_t=*(MapBkgnd+loc);
  728.       tile_m=*(MapFrgnd+loc)+tilenum;
  729.       tile_i=*(MapInfoPl+loc)+tilenum;
  730.  
  731.       CombineTiles(viewton?tile_t:-BkgndColor,viewmon?tile_m:0,viewion?tile_i:0,tsize);
  732.       if (GridMode)
  733.     Overlay(tsize);
  734.       DrawTile((px+i-xbase)<<(tsize-1),(py+j-ybase)*(4<<tsize)+8,tsize);
  735.      }
  736.  
  737.  MouseShow();
  738. }
  739.  
  740.  
  741. ////////////////////////////////////////////////////
  742. //
  743. // SAVE CUT BUFFERS TO XMS BEFORE MAP LOAD/CREATE
  744. //
  745. ////////////////////////////////////////////////////
  746. void SaveCutBuffers(void)
  747. {
  748.  long size,off;
  749.  int j;
  750.  
  751.  //
  752.  // IS SOMETHING IN THE COPY BUFFER?
  753.  // IF SO, PRESERVE AS MUCH AS POSSIBLE
  754.  //
  755.  if (!TileCopy.MapOrTileSelect)
  756.    {
  757.     size=(2L*TileCopy.w*TileCopy.h)*(((TileCopy.PlanesCopied&BPLANE)>0)+
  758.       ((TileCopy.PlanesCopied&FPLANE)>0)+((TileCopy.PlanesCopied&IPLANE)>0));
  759.  
  760.     xms1=XMSAllocate(size);
  761.  
  762.     off=0;
  763.     if (TileCopy.PlanesCopied&BPLANE)
  764.       for (j=0;j<TileCopy.h;j++)
  765.     {
  766.      XMSmove(0,(long)MK_FP(CutBkgnd,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
  767.        xms1,off,2L*TileCopy.w);
  768.      off+=2L*TileCopy.w;
  769.     }
  770.  
  771.     if (TileCopy.PlanesCopied&FPLANE)
  772.       for (j=0;j<TileCopy.h;j++)
  773.     {
  774.      XMSmove(0,(long)MK_FP(CutFrgnd,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
  775.        xms1,off,2L*TileCopy.w);
  776.      off+=2L*TileCopy.w;
  777.     }
  778.  
  779.     if (TileCopy.PlanesCopied&IPLANE)
  780.       for (j=0;j<TileCopy.h;j++)
  781.     {
  782.      XMSmove(0,(long)MK_FP(CutInfoPl,2L*((TileCopy.y+j)*mapwidth)+2L*TileCopy.x),
  783.        xms1,off,2L*TileCopy.w);
  784.      off+=2L*TileCopy.w;
  785.     }
  786.    }
  787. }
  788.  
  789.  
  790. ////////////////////////////////////////////////////
  791. //
  792. // RESTORE CUT BUFFERS FROM XMS AFTER MAP LOAD/CREATE
  793. //
  794. ////////////////////////////////////////////////////
  795. void RestoreCutBuffers(void)
  796. {
  797.  //
  798.  // COPY BACK STUFF IN XMS
  799.  //
  800.  if (!TileCopy.MapOrTileSelect)
  801.    {
  802.     long ToOff,off;
  803.     int newwidth,newheight,j;
  804.  
  805.     newwidth=(TileCopy.w>mapwidth)?mapwidth:TileCopy.w;
  806.     newheight=(TileCopy.h>mapheight)?mapheight:TileCopy.h;
  807.  
  808.     ToOff=off=0;
  809.  
  810.     if (TileCopy.PlanesCopied&BPLANE)
  811.       for (j=0;j<newheight;j++)
  812.     {
  813.      XMSmove(xms1,off,0,(long)MK_FP(CutBkgnd,2L*(j*mapwidth)),2L*newwidth);
  814.      ToOff+=2L*newwidth;
  815.      off+=2L*TileCopy.w;
  816.     }
  817.  
  818.     if (TileCopy.PlanesCopied&FPLANE)
  819.       for (j=0;j<newheight;j++)
  820.     {
  821.      XMSmove(xms1,off,0,(long)MK_FP(CutFrgnd,2L*(j*mapwidth)),2L*newwidth);
  822.      ToOff+=2L*newwidth;
  823.      off+=2L*TileCopy.w;
  824.     }
  825.  
  826.     if (TileCopy.PlanesCopied&IPLANE)
  827.       for (j=0;j<newheight;j++)
  828.     {
  829.      XMSmove(xms1,off,0,(long)MK_FP(CutInfoPl,2L*(j*mapwidth)),2L*newwidth);
  830.      ToOff+=2L*newwidth;
  831.      off+=2L*TileCopy.w;
  832.     }
  833.  
  834.     TileCopy.x=TileCopy.y=0;
  835.     TileCopy.w=newwidth;
  836.     TileCopy.h=newheight;
  837.  
  838.     XMSFreeMem(xms1);    // RELEASE THE MEMORY
  839.    }
  840. }
  841.  
  842. ////////////////////////////////////////////////////
  843. //
  844. // SEE IF THERE'S AN INFO VALUES AT THE CURRENT POSITION
  845. // THAT NEEDS TO BE PRINTED
  846. //
  847. ////////////////////////////////////////////////////
  848. void CheckInfoValues(int i,int j,int tilei)
  849. {
  850.  sx=i<<(tsize-1);
  851.  sy=(j<<(tsize-1))+1;
  852.  
  853.  if (TsearchMode)
  854.    {
  855.     unsigned loc,temp,p=0;
  856.  
  857.     loc=(j+ybase)*mapwidth+i+xbase;
  858.  
  859.     if (planeton)
  860.       {
  861.        if (MapBkgnd[loc]==whicht)
  862.      {
  863.       temp=whicht;
  864.       p=1;
  865.      }
  866.       }
  867.     else
  868.     if (planemon)
  869.       {
  870.        if (MapFrgnd[loc]==whichtm-tilenum)
  871.      {
  872.       temp=whichtm-tilenum;
  873.       p=1;
  874.      }
  875.       }
  876.     else
  877.     if (planeion)
  878.       if ((unsigned)MapInfoPl[loc]==whichi-tilenum)
  879.     {
  880.      temp=whichi-tilenum;
  881.      p=1;
  882.     }
  883.  
  884.     if (p)
  885.       switch(tsize)
  886.       {
  887.        case 1:
  888.      print("#");
  889.      break;
  890.        case 2:
  891.      printhexb(temp>>8);
  892.      sx-=2;
  893.      sy++;
  894.      printhexb(temp&0xff);
  895.      break;
  896.        case 3: printhex(temp);
  897.       }
  898.    }
  899.  else
  900.  if (viewion && tilei>lasticon)
  901.    {
  902.     switch(tsize)
  903.     {
  904.      case 1:
  905.        print("#");
  906.        break;
  907.      case 2:
  908.        printhexb(tilei-tilenum>>8);
  909.        sx-=2;
  910.        sy++;
  911.        printhexb(tilei-tilenum&0xff);
  912.        break;
  913.      case 3: printhex(tilei-tilenum);
  914.     }
  915.    }
  916. }
  917.  
  918. ////////////////////////////////////////////////////
  919. //
  920. // Item - Edit Map Edges
  921. //
  922. ////////////////////////////////////////////////////
  923. btype MapEdgeB[]={{"\xb",7,3,1},
  924.           {"\xc",7,7,1},
  925.           {"\xe",4,5,1},
  926.           {"\x1f",10,5,1},
  927.           {" Exit ",5,16,2}};
  928. DialogDef MapEdgeD={"  PICK MAP EDGE\n"
  929.             "    TO CHANGE",
  930.             16,18,5,&MapEdgeB[0],NULL};
  931.  
  932. void Item_EditMapEdges(void)
  933. {
  934.  int which,val,newwidth,newheight,b,f,i,
  935.     _seg *tempB,_seg *tempF,_seg *tempI;
  936.  unsigned dx,dy,obx,oby,k,j,modified=0;
  937.  long size;
  938.  
  939.  b=MapFileHeader->maptype&BPLANE;
  940.  f=MapFileHeader->maptype&FPLANE;
  941.  i=MapFileHeader->maptype&IPLANE;
  942.  
  943.  DrawDialog(&MapEdgeD,1);
  944.  GetDialogXY(&MapEdgeD,&dx,&dy);
  945.  do
  946.  {
  947.   MouseHide();
  948.   sx=dx+2;
  949.   sy=dy+14;
  950.   print("W:");
  951.   printint(MapHeader.width);
  952.   print(", H:");
  953.   printint(MapHeader.height);
  954.   print("   ");
  955.   MouseShow();
  956.  
  957.  
  958.   which=CheckButtons(&MapEdgeD);
  959.   GetButtonXY(&MapEdgeD,which-1,&obx,&oby);
  960.   MouseHide();
  961.   if (which>=1 && which<=4)
  962.     {
  963.      // DRAW INPUT BAR
  964.      sx=dx;
  965.      sy=dy+9;
  966.      print("+ or - value");
  967.      DrawBorder(dx,dy+10,15,2,1);
  968.  
  969.      // INPUT VALUE
  970.      sx=dx+1;
  971.      sy=dy+11;
  972.      val=inputint(9);
  973.  
  974.      // ERASE THE ARROW AND INPUT BAR
  975.      sx=obx;
  976.      sy=oby;
  977.      print(MapEdgeB[which-1].text);
  978.      bar(dx,dy+9,dx+15,dy+12,' ');
  979.  
  980.      // CHECK FOR ESC
  981.      if (val==(int)ESCOUT)
  982.        which=6;
  983.     }
  984.  
  985.   MouseShow();
  986.   switch(which)
  987.   {
  988.    //
  989.    // ADD OR DELETE FROM TOP
  990.    //
  991.    case 1:
  992.      newheight=mapheight+val;
  993.      size=2L*newheight*mapwidth;
  994.      if (size<=0 || size>0x10000L)
  995.        {
  996.     RestoreBackground();
  997.     ErrDialog("Invalid Map height!"," OK ");
  998.     return;
  999.        }
  1000.  
  1001.      // FREE UP SOME MEMORY!
  1002.      SaveCutBuffers();
  1003.      RemoveUndoBuffers();
  1004.  
  1005.      if (b)
  1006.        {
  1007.     MMFreePtr((memptr *)&CutBkgnd);
  1008.     MMAllocate((memptr *)&tempB,size);
  1009.        }
  1010.      if (f)
  1011.        {
  1012.     MMFreePtr((memptr *)&CutFrgnd);
  1013.     MMAllocate((memptr *)&tempF,size);
  1014.        }
  1015.      if (i)
  1016.        {
  1017.     MMFreePtr((memptr *)&CutInfoPl);
  1018.     MMAllocate((memptr *)&tempI,size);
  1019.        }
  1020.  
  1021.      if (val<0)
  1022.        {
  1023.     // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
  1024.     for (j=abs(val);j<mapheight;j++)
  1025.       for (k=0;k<mapwidth;k++)
  1026.         {
  1027.          if (b)
  1028.            tempB[(j+val)*mapwidth+k]=MapBkgnd[j*mapwidth+k];
  1029.          if (f)
  1030.            tempF[(j+val)*mapwidth+k]=MapFrgnd[j*mapwidth+k];
  1031.          if (i)
  1032.            tempI[(j+val)*mapwidth+k]=MapInfoPl[j*mapwidth+k];
  1033.         }
  1034.        }
  1035.      else
  1036.        {
  1037.     for (j=0;j<mapheight+val;j++)
  1038.       for (k=0;k<mapwidth;k++)
  1039.         {
  1040.          if (j<abs(val))
  1041.            {
  1042.         if (b)
  1043.           tempB[j*mapwidth+k]=whicht;
  1044.         if (f)
  1045.           tempF[j*mapwidth+k]=whichtm-tilenum;
  1046.         if (i)
  1047.           tempI[j*mapwidth+k]=whichi-tilenum;
  1048.            }
  1049.          else
  1050.            {
  1051.         if (b)
  1052.           tempB[j*mapwidth+k]=MapBkgnd[(j-val)*mapwidth+k];
  1053.         if (f)
  1054.           tempF[j*mapwidth+k]=MapFrgnd[(j-val)*mapwidth+k];
  1055.         if (i)
  1056.           tempI[j*mapwidth+k]=MapInfoPl[(j-val)*mapwidth+k];
  1057.            }
  1058.         }
  1059.        }
  1060.  
  1061.      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
  1062.      if (b)
  1063.        {
  1064.     MMFreePtr((memptr *)&MapBkgnd);
  1065.     MMAllocate((memptr *)&MapBkgnd,size);
  1066.        }
  1067.      if (f)
  1068.        {
  1069.     MMFreePtr((memptr *)&MapFrgnd);
  1070.     MMAllocate((memptr *)&MapFrgnd,size);
  1071.        }
  1072.      if (i)
  1073.        {
  1074.     MMFreePtr((memptr *)&MapInfoPl);
  1075.     MMAllocate((memptr *)&MapInfoPl,size);
  1076.        }
  1077.  
  1078.      // COPY THE REGION BACK IN...
  1079.      for (j=0;j<newheight;j++)
  1080.        for (k=0;k<mapwidth;k++)
  1081.      {
  1082.       if (b)
  1083.         MapBkgnd[j*mapwidth+k]=tempB[j*mapwidth+k];
  1084.       if (f)
  1085.         MapFrgnd[j*mapwidth+k]=tempF[j*mapwidth+k];
  1086.       if (i)
  1087.         MapInfoPl[j*mapwidth+k]=tempI[j*mapwidth+k];
  1088.      }
  1089.  
  1090.      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
  1091.      if (b)
  1092.        {
  1093.     MMFreePtr((memptr *)&tempB);
  1094.     MMAllocate((memptr *)&CutBkgnd,size);
  1095.        }
  1096.      if (f)
  1097.        {
  1098.     MMFreePtr((memptr *)&tempF);
  1099.     MMAllocate((memptr *)&CutFrgnd,size);
  1100.        }
  1101.      if (i)
  1102.        {
  1103.     MMFreePtr((memptr *)&tempI);
  1104.     MMAllocate((memptr *)&CutInfoPl,size);
  1105.        }
  1106.  
  1107.      mapheight=newheight;
  1108.      MapHeader.height=newheight;
  1109.      modified=DirtyFlag=1;
  1110.      AllocateUndoBuffers();
  1111.      UndoRegion.x=-1;
  1112.      SaveUndo(0,0,mapwidth,mapheight);
  1113.      RestoreCutBuffers();
  1114.  
  1115.      break;
  1116.  
  1117.    //
  1118.    // ADD OR DELETE FROM BOTTOM
  1119.    //
  1120.    case 2:
  1121.      newheight=mapheight+val;
  1122.      size=2L*newheight*mapwidth;
  1123.      if (size<=0 || size>0x10000L)
  1124.        {
  1125.     RestoreBackground();
  1126.     ErrDialog("Invalid Map height!"," OK ");
  1127.     return;
  1128.        }
  1129.  
  1130.      // FREE UP SOME MEMORY!
  1131.      SaveCutBuffers();
  1132.      RemoveUndoBuffers();
  1133.      if (b)
  1134.        {
  1135.     MMFreePtr((memptr *)&CutBkgnd);
  1136.     MMAllocate((memptr *)&tempB,size);
  1137.        }
  1138.      if (f)
  1139.        {
  1140.     MMFreePtr((memptr *)&CutFrgnd);
  1141.     MMAllocate((memptr *)&tempF,size);
  1142.        }
  1143.      if (i)
  1144.        {
  1145.     MMFreePtr((memptr *)&CutInfoPl);
  1146.     MMAllocate((memptr *)&tempI,size);
  1147.        }
  1148.  
  1149.      if (val<0)
  1150.        {
  1151.     // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
  1152.     for (j=0;j<mapheight+val;j++)
  1153.       for (k=0;k<mapwidth;k++)
  1154.         {
  1155.          if (b)
  1156.            tempB[j*mapwidth+k]=MapBkgnd[j*mapwidth+k];
  1157.          if (f)
  1158.            tempF[j*mapwidth+k]=MapFrgnd[j*mapwidth+k];
  1159.          if (i)
  1160.            tempI[j*mapwidth+k]=MapInfoPl[j*mapwidth+k];
  1161.         }
  1162.        }
  1163.      else
  1164.        {
  1165.     for (j=0;j<mapheight+val;j++)
  1166.       for (k=0;k<mapwidth;k++)
  1167.         {
  1168.          if (j>=mapheight)
  1169.            {
  1170.         if (b)
  1171.           tempB[j*mapwidth+k]=whicht;
  1172.         if (f)
  1173.           tempF[j*mapwidth+k]=whichtm-tilenum;
  1174.         if (i)
  1175.           tempI[j*mapwidth+k]=whichi-tilenum;
  1176.            }
  1177.          else
  1178.            {
  1179.         if (b)
  1180.           tempB[j*mapwidth+k]=MapBkgnd[j*mapwidth+k];
  1181.         if (f)
  1182.           tempF[j*mapwidth+k]=MapFrgnd[j*mapwidth+k];
  1183.         if (i)
  1184.           tempI[j*mapwidth+k]=MapInfoPl[j*mapwidth+k];
  1185.            }
  1186.         }
  1187.        }
  1188.  
  1189.      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
  1190.      if (b)
  1191.        {
  1192.     MMFreePtr((memptr *)&MapBkgnd);
  1193.     MMAllocate((memptr *)&MapBkgnd,size);
  1194.        }
  1195.      if (f)
  1196.        {
  1197.     MMFreePtr((memptr *)&MapFrgnd);
  1198.     MMAllocate((memptr *)&MapFrgnd,size);
  1199.        }
  1200.      if (i)
  1201.        {
  1202.     MMFreePtr((memptr *)&MapInfoPl);
  1203.     MMAllocate((memptr *)&MapInfoPl,size);
  1204.        }
  1205.  
  1206.      // COPY THE REGION BACK IN...
  1207.      for (j=0;j<newheight;j++)
  1208.        for (k=0;k<mapwidth;k++)
  1209.      {
  1210.       if (b)
  1211.         MapBkgnd[j*mapwidth+k]=tempB[j*mapwidth+k];
  1212.       if (f)
  1213.         MapFrgnd[j*mapwidth+k]=tempF[j*mapwidth+k];
  1214.       if (i)
  1215.         MapInfoPl[j*mapwidth+k]=tempI[j*mapwidth+k];
  1216.      }
  1217.  
  1218.      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
  1219.      if (b)
  1220.        {
  1221.     MMFreePtr((memptr *)&tempB);
  1222.     MMAllocate((memptr *)&CutBkgnd,size);
  1223.        }
  1224.      if (f)
  1225.        {
  1226.     MMFreePtr((memptr *)&tempF);
  1227.     MMAllocate((memptr *)&CutFrgnd,size);
  1228.        }
  1229.      if (i)
  1230.        {
  1231.     MMFreePtr((memptr *)&tempI);
  1232.     MMAllocate((memptr *)&CutInfoPl,size);
  1233.        }
  1234.  
  1235.      mapheight=newheight;
  1236.      MapHeader.height=newheight;
  1237.      modified=DirtyFlag=1;
  1238.      AllocateUndoBuffers();
  1239.      UndoRegion.x=-1;
  1240.      SaveUndo(0,0,mapwidth,mapheight);
  1241.      RestoreCutBuffers();
  1242.  
  1243.      break;
  1244.  
  1245.    //
  1246.    // ADD OR DELETE FROM LEFTEDGE
  1247.    //
  1248.    case 3:
  1249.      newwidth=mapwidth+val;
  1250.      size=2L*newwidth*mapheight;
  1251.      if (size<=0 || size>0x10000L)
  1252.        {
  1253.     RestoreBackground();
  1254.     ErrDialog("Invalid Map width!"," OK ");
  1255.     return;
  1256.        }
  1257.  
  1258.      // FREE UP SOME MEMORY!
  1259.      SaveCutBuffers();
  1260.      RemoveUndoBuffers();
  1261.      if (b)
  1262.        {
  1263.     MMFreePtr((memptr *)&CutBkgnd);
  1264.     MMAllocate((memptr *)&tempB,size);
  1265.        }
  1266.      if (f)
  1267.        {
  1268.     MMFreePtr((memptr *)&CutFrgnd);
  1269.     MMAllocate((memptr *)&tempF,size);
  1270.        }
  1271.      if (i)
  1272.        {
  1273.     MMFreePtr((memptr *)&CutInfoPl);
  1274.     MMAllocate((memptr *)&tempI,size);
  1275.        }
  1276.  
  1277.      if (val<0)
  1278.        {
  1279.     // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
  1280.     for (j=0;j<mapheight;j++)
  1281.       for (k=abs(val);k<mapwidth;k++)
  1282.         {
  1283.          if (b)
  1284.            tempB[j*newwidth+k+val]=MapBkgnd[j*mapwidth+k];
  1285.          if (f)
  1286.            tempF[j*newwidth+k+val]=MapFrgnd[j*mapwidth+k];
  1287.          if (i)
  1288.            tempI[j*newwidth+k+val]=MapInfoPl[j*mapwidth+k];
  1289.         }
  1290.        }
  1291.      else
  1292.        {
  1293.     for (j=0;j<mapheight;j++)
  1294.       for (k=0;k<mapwidth+val;k++)
  1295.         {
  1296.          if (k<abs(val))
  1297.            {
  1298.         if (b)
  1299.           tempB[j*newwidth+k]=whicht;
  1300.         if (f)
  1301.           tempF[j*newwidth+k]=whichtm-tilenum;
  1302.         if (i)
  1303.           tempI[j*newwidth+k]=whichi-tilenum;
  1304.            }
  1305.          else
  1306.            {
  1307.         if (b)
  1308.           tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k-val];
  1309.         if (f)
  1310.           tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k-val];
  1311.         if (i)
  1312.           tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k-val];
  1313.            }
  1314.         }
  1315.        }
  1316.  
  1317.      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
  1318.      if (b)
  1319.        {
  1320.     MMFreePtr((memptr *)&MapBkgnd);
  1321.     MMAllocate((memptr *)&MapBkgnd,size);
  1322.        }
  1323.      if (f)
  1324.        {
  1325.     MMFreePtr((memptr *)&MapFrgnd);
  1326.     MMAllocate((memptr *)&MapFrgnd,size);
  1327.        }
  1328.      if (i)
  1329.        {
  1330.     MMFreePtr((memptr *)&MapInfoPl);
  1331.     MMAllocate((memptr *)&MapInfoPl,size);
  1332.        }
  1333.  
  1334.      // COPY THE REGION BACK IN...
  1335.      for (j=0;j<mapheight;j++)
  1336.        for (k=0;k<newwidth;k++)
  1337.      {
  1338.       if (b)
  1339.         MapBkgnd[j*newwidth+k]=tempB[j*newwidth+k];
  1340.       if (f)
  1341.         MapFrgnd[j*newwidth+k]=tempF[j*newwidth+k];
  1342.       if (i)
  1343.         MapInfoPl[j*newwidth+k]=tempI[j*newwidth+k];
  1344.      }
  1345.  
  1346.      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
  1347.      if (b)
  1348.        {
  1349.     MMFreePtr((memptr *)&tempB);
  1350.     MMAllocate((memptr *)&CutBkgnd,size);
  1351.        }
  1352.      if (f)
  1353.        {
  1354.     MMFreePtr((memptr *)&tempF);
  1355.     MMAllocate((memptr *)&CutFrgnd,size);
  1356.        }
  1357.      if (i)
  1358.        {
  1359.     MMFreePtr((memptr *)&tempI);
  1360.     MMAllocate((memptr *)&CutInfoPl,size);
  1361.        }
  1362.  
  1363.      mapwidth=newwidth;
  1364.      MapHeader.width=newwidth;
  1365.      modified=DirtyFlag=1;
  1366.      AllocateUndoBuffers();
  1367.      UndoRegion.x=-1;
  1368.      SaveUndo(0,0,mapwidth,mapheight);
  1369.      RestoreCutBuffers();
  1370.  
  1371.      break;
  1372.  
  1373.    //
  1374.    // ADD OR DELETE FROM RIGHTEDGE
  1375.    //
  1376.    case 4:
  1377.      newwidth=mapwidth+val;
  1378.      size=2L*newwidth*mapheight;
  1379.      if (size<=0 || size>0x10000L)
  1380.        {
  1381.     RestoreBackground();
  1382.     ErrDialog("Invalid Map width!"," OK ");
  1383.     return;
  1384.        }
  1385.  
  1386.      // FREE UP SOME MEMORY!
  1387.      SaveCutBuffers();
  1388.      RemoveUndoBuffers();
  1389.      if (b)
  1390.        {
  1391.     MMFreePtr((memptr *)&CutBkgnd);
  1392.     MMAllocate((memptr *)&tempB,size);
  1393.        }
  1394.      if (f)
  1395.        {
  1396.     MMFreePtr((memptr *)&CutFrgnd);
  1397.     MMAllocate((memptr *)&tempF,size);
  1398.        }
  1399.      if (i)
  1400.        {
  1401.     MMFreePtr((memptr *)&CutInfoPl);
  1402.     MMAllocate((memptr *)&tempI,size);
  1403.        }
  1404.  
  1405.      if (val<0)
  1406.        {
  1407.     // COPY MAP PLANES INTO TEMP MEMORY (CLIPPED, HERE)
  1408.     for (j=0;j<mapheight;j++)
  1409.       for (k=0;k<mapwidth+val;k++)
  1410.         {
  1411.          if (b)
  1412.            tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k];
  1413.          if (f)
  1414.            tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k];
  1415.          if (i)
  1416.            tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k];
  1417.         }
  1418.        }
  1419.      else
  1420.        {
  1421.     for (j=0;j<mapheight;j++)
  1422.       for (k=0;k<mapwidth+val;k++)
  1423.         {
  1424.          if (k>=mapwidth)
  1425.            {
  1426.         if (b)
  1427.           tempB[j*newwidth+k]=whicht;
  1428.         if (f)
  1429.           tempF[j*newwidth+k]=whichtm-tilenum;
  1430.         if (i)
  1431.           tempI[j*newwidth+k]=whichi-tilenum;
  1432.            }
  1433.          else
  1434.            {
  1435.         if (b)
  1436.           tempB[j*newwidth+k]=MapBkgnd[j*mapwidth+k];
  1437.         if (f)
  1438.           tempF[j*newwidth+k]=MapFrgnd[j*mapwidth+k];
  1439.         if (i)
  1440.           tempI[j*newwidth+k]=MapInfoPl[j*mapwidth+k];
  1441.            }
  1442.         }
  1443.        }
  1444.  
  1445.      // DEALLOCATE & REALLOCATE THE MAP BUFFERS, RESIZED
  1446.      if (b)
  1447.        {
  1448.     MMFreePtr((memptr *)&MapBkgnd);
  1449.     MMAllocate((memptr *)&MapBkgnd,size);
  1450.        }
  1451.      if (f)
  1452.        {
  1453.     MMFreePtr((memptr *)&MapFrgnd);
  1454.     MMAllocate((memptr *)&MapFrgnd,size);
  1455.        }
  1456.      if (i)
  1457.        {
  1458.     MMFreePtr((memptr *)&MapInfoPl);
  1459.     MMAllocate((memptr *)&MapInfoPl,size);
  1460.        }
  1461.  
  1462.      // COPY THE REGION BACK IN...
  1463.      for (j=0;j<mapheight;j++)
  1464.        for (k=0;k<newwidth;k++)
  1465.      {
  1466.       if (b)
  1467.         MapBkgnd[j*newwidth+k]=tempB[j*newwidth+k];
  1468.       if (f)
  1469.         MapFrgnd[j*newwidth+k]=tempF[j*newwidth+k];
  1470.       if (i)
  1471.         MapInfoPl[j*newwidth+k]=tempI[j*newwidth+k];
  1472.      }
  1473.  
  1474.      // TOAST THE 'TEMP' BUFFERS & REALLOCATE THE 'CUT' BUFFERS
  1475.      if (b)
  1476.        {
  1477.     MMFreePtr((memptr *)&tempB);
  1478.     MMAllocate((memptr *)&CutBkgnd,size);
  1479.        }
  1480.      if (f)
  1481.        {
  1482.     MMFreePtr((memptr *)&tempF);
  1483.     MMAllocate((memptr *)&CutFrgnd,size);
  1484.        }
  1485.      if (i)
  1486.        {
  1487.     MMFreePtr((memptr *)&tempI);
  1488.     MMAllocate((memptr *)&CutInfoPl,size);
  1489.        }
  1490.  
  1491.      mapwidth=newwidth;
  1492.      MapHeader.width=newwidth;
  1493.      modified=DirtyFlag=1;
  1494.      AllocateUndoBuffers();
  1495.      UndoRegion.x=-1;
  1496.      SaveUndo(0,0,mapwidth,mapheight);
  1497.      RestoreCutBuffers();
  1498.      break;
  1499.   }
  1500.  } while(which && which!=5);
  1501.  RestoreBackground();
  1502.  if (modified)
  1503.    {
  1504.     xbase=ybase=0;
  1505.     MouseHide();
  1506.     InitDesktop(TED5MenuBar,0);
  1507.     DrawInfoBar();
  1508.     DrawMap();
  1509.     MouseShow();
  1510.    }
  1511. }
  1512.  
  1513.  
  1514. ////////////////////////////////////////////////////
  1515. //
  1516. // Display amount of memory available
  1517. //
  1518. ////////////////////////////////////////////////////
  1519. btype     ShowMemb={" OK ",6,11,2};
  1520. DialogDef ShowMemd={"Extended Memory \n"
  1521.             "Available:\n\n"
  1522.             "Main Memory\n"
  1523.             "Available:\n\n"
  1524.             "In Extended Mem\n"
  1525.             "----------------\n"
  1526.             "CGA:     EGA:\n"
  1527.             "VGA:    Maps:"
  1528.             ,16,13,1,&ShowMemb,PrintMem};
  1529.  
  1530. void Item_PrintMem(void)
  1531. {
  1532.  DoDialog(&ShowMemd);
  1533. }
  1534.  
  1535. void PrintMem(int x,int y)
  1536. {
  1537.  long total;
  1538.  char memstring[10];
  1539.  
  1540.  sx=x+10;
  1541.  sy=y+1;
  1542.  itoa(XMSTotalFree(),memstring,10);
  1543.  strcat(memstring,"K");
  1544.  print(memstring);
  1545.  
  1546.  sx=x+10;
  1547.  sy=y+4;
  1548.  total=(MMTotalFree()*16L)/1024;
  1549.  ltoa(total,memstring,10);
  1550.  strcat(memstring,"K");
  1551.  print(memstring);
  1552.  
  1553.  sx=x+4;
  1554.  sy=y+8;
  1555.  if (!CgaXMS)
  1556.    print("No");
  1557.  else
  1558.    print("Yes");
  1559.  
  1560.  sx=x+13;
  1561.  sy=y+8;
  1562.  if (!EgaXMS)
  1563.    print("No");
  1564.  else
  1565.    print("Yes");
  1566.  
  1567.  sx=x+4;
  1568.  sy=y+9;
  1569.  if (!VgaXMS)
  1570.    print("No");
  1571.  else
  1572.    print("Yes");
  1573.  
  1574.  
  1575.  sx=x+13;
  1576.  sy=y+9;
  1577.  if (!XMSmaps)
  1578.    print("No");
  1579.  else
  1580.    print("Yes");
  1581. }
  1582.  
  1583.  
  1584. ////////////////////////////////////////////////////
  1585. //
  1586. // CARMACIZE THE MAP FILE!
  1587. //
  1588. ////////////////////////////////////////////////////
  1589. void Item_Huffman(void)
  1590. {
  1591.  OutputHeadStr NewFileHeader;
  1592.  char huffname[14]="GAMEMAPS.",huffheadname[14]="MAPSHEAD.",tempstr[200],
  1593.     mapidstr[8]=IDSTRING,objname[14],dictname[14],tempname[14];
  1594.  int dx,dy,i,oxb,oyb,maplengths[100];
  1595.  MapHeaderStr TempHeader;
  1596.  memptr block,block1,block2;
  1597.  long size,fsize,nsize;
  1598.  
  1599.  
  1600.  Item_SaveMap();
  1601.  
  1602.  strcat(huffname,ext);
  1603.  strcat(huffheadname,ext);
  1604.  strcpy(tempstr,"This will take a while.\n");
  1605.  strcat(tempstr,huffname);
  1606.  strcat(tempstr,". [               ]");
  1607.  ErrDialog(tempstr,"");
  1608.  dy=sy;
  1609.  dx=sx-16;
  1610.  
  1611.  oxb=xbase;
  1612.  oyb=ybase;
  1613.  //
  1614.  // Free up memory
  1615.  //
  1616.  if (MapBkgnd)
  1617.    {
  1618.     MMFreePtr((memptr *)&MapBkgnd);
  1619.     MMFreePtr((memptr *)&CutBkgnd);
  1620.    }
  1621.  if (MapFrgnd)
  1622.    {
  1623.     MMFreePtr((memptr *)&MapFrgnd);
  1624.     MMFreePtr((memptr *)&CutFrgnd);
  1625.    }
  1626.  if (MapInfoPl)
  1627.    {
  1628.     MMFreePtr((memptr *)&MapInfoPl);
  1629.     MMFreePtr((memptr *)&CutInfoPl);
  1630.    }
  1631.  
  1632.  //
  1633.  // Now, time to Carmacize all the maps
  1634.  //
  1635.  sx=dx;
  1636.  sy=dy;
  1637.  print("Carmacizing");
  1638.  dx=sx+1;
  1639.  
  1640.  fsize=0;
  1641.  SaveFile(huffname,(char huge *)&mapidstr,fsize,strlen(mapidstr));
  1642.  fsize+=strlen(mapidstr);
  1643.  
  1644.  memset(&maplengths,0,sizeof(long)*100);
  1645.  memset(&NewFileHeader,0,sizeof(OutputHeadStr));
  1646.  MMAllocate(&block1,sizeof(MapHeaderStr));
  1647.  for (i=0;i<100;i++)
  1648.    if (MapFileHeader->dataoffsets[i]!=-1)
  1649.      {
  1650.       //
  1651.       // LOAD MAP HEADER
  1652.       //
  1653.       sx=dx;
  1654.       printint(i);
  1655.       LoadFile(mapname,(char huge *)&TempHeader,MapFileHeader->dataoffsets[i],sizeof(MapHeaderStr));
  1656.  
  1657.       //
  1658.       // COMPRESS EACH MAP PLANE
  1659.       //
  1660.       #pragma warn -sus
  1661.       if (MapFileHeader->maptype&BPLANE)
  1662.     {
  1663.      size=TempHeader.mapbkgndlen;
  1664.      MMAllocate(&block,size);
  1665.      MMAllocate(&block2,size);
  1666.      LoadFile(mapname,block,TempHeader.mapbkgndpl,size);
  1667.      *(int _seg *)block2=TempHeader.mapbkgndlen;
  1668.      nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned char huge *)block2+2)+2;
  1669.      maplengths[i]+=nsize;
  1670.      if (nsize==2)
  1671.      {
  1672.       RestoreBackground();
  1673.       MMFreePtr(&block2);
  1674.       MMFreePtr(&block);
  1675.       MMFreePtr(&block1);
  1676.       LoadMap(whichmap);
  1677.       xbase=oxb;
  1678.       ybase=oyb;
  1679.       ErrDialog("ESC out of this infernal thing!"," YES! ");
  1680.       return;
  1681.      }
  1682.  
  1683.      SaveFile(huffname,block2,fsize,nsize);
  1684.      TempHeader.mapbkgndpl=fsize;
  1685.      TempHeader.mapbkgndlen=nsize;
  1686.      MMFreePtr(&block2);
  1687.      MMFreePtr(&block);
  1688.      fsize+=nsize;
  1689.     }
  1690.       if (MapFileHeader->maptype&FPLANE)
  1691.     {
  1692.      size=TempHeader.mapfrgndlen;
  1693.      MMAllocate(&block,size);
  1694.      MMAllocate(&block2,size);
  1695.      LoadFile(mapname,block,TempHeader.mapfrgndpl,size);
  1696.      *(int _seg *)block2=TempHeader.mapfrgndlen;
  1697.      nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned  char huge *)block2+2)+2;
  1698.      maplengths[i]+=nsize;
  1699.      if (nsize==2)
  1700.      {
  1701.       RestoreBackground();
  1702.       MMFreePtr(&block2);
  1703.       MMFreePtr(&block);
  1704.       MMFreePtr(&block1);
  1705.       LoadMap(whichmap);
  1706.       xbase=oxb;
  1707.       ybase=oyb;
  1708.       ErrDialog("ESC out of this infernal thing!"," YES! ");
  1709.       return;
  1710.      }
  1711.  
  1712.      SaveFile(huffname,block2,fsize,nsize);
  1713.      TempHeader.mapfrgndpl=fsize;
  1714.      TempHeader.mapfrgndlen=nsize;
  1715.      MMFreePtr(&block2);
  1716.      MMFreePtr(&block);
  1717.      fsize+=nsize;
  1718.     }
  1719.       if (MapFileHeader->maptype&IPLANE)
  1720.     {
  1721.      size=TempHeader.mapinfolen;
  1722.      MMAllocate(&block,size);
  1723.      MMAllocate(&block2,size);
  1724.      LoadFile(mapname,block,TempHeader.mapinfopl,size);
  1725.      *(int _seg *)block2=TempHeader.mapinfolen;
  1726.      nsize=CarmackCompress((unsigned  char huge *)block,size,(unsigned  char huge *)block2+2)+2;
  1727.      maplengths[i]+=nsize;
  1728.      if (nsize==2)
  1729.      {
  1730.       RestoreBackground();
  1731.       MMFreePtr(&block2);
  1732.       MMFreePtr(&block);
  1733.       MMFreePtr(&block1);
  1734.       LoadMap(whichmap);
  1735.       xbase=oxb;
  1736.       ybase=oyb;
  1737.       ErrDialog("ESC out of this infernal thing!"," YES! ");
  1738.       return;
  1739.      }
  1740.  
  1741.      SaveFile(huffname,block2,fsize,nsize);
  1742.      TempHeader.mapinfopl=fsize;
  1743.      TempHeader.mapinfolen=nsize;
  1744.      MMFreePtr(&block2);
  1745.      MMFreePtr(&block);
  1746.      fsize+=nsize;
  1747.     }
  1748.       #pragma warn +sus
  1749.  
  1750.       //
  1751.       // SAVE MAP HEADER
  1752.       //
  1753.       nsize=sizeof(TempHeader);
  1754.       maplengths[i]+=nsize;
  1755.       SaveFile(huffname,(char huge *)&TempHeader,fsize,nsize);
  1756.       NewFileHeader.dataoffsets[i]=fsize;
  1757.       fsize+=nsize;
  1758.  
  1759.       SaveFile(huffname,"!ID!",fsize,4);
  1760.       fsize+=4;
  1761.      }
  1762.  MMFreePtr(&block1);
  1763.  
  1764.  
  1765.  //
  1766.  // COPY PERTINENT MAPFILEHEADER DATA TO NEWFILEHEADER
  1767.  //
  1768.  {
  1769.   char outname[14],tempname[14]="MTEMP.TMP",doutname[14];
  1770.  
  1771.  
  1772.   strcpy(outname,ext);
  1773.   strcat(outname,"MHEAD.OBJ");
  1774.  
  1775.   NewFileHeader.RLEWtag=MapFileHeader->RLEWtag;
  1776.   fsize=sizeof(OutputHeadStr);
  1777.   SaveFile(tempname,(char huge *)&NewFileHeader,0,fsize);
  1778.  
  1779.   for (i=0;i<numtplanes;i++)
  1780.     {
  1781.      SaveFile(tempname,MK_FP(Tinfo[i],0),fsize,tilenum);
  1782.      fsize+=tilenum;
  1783.     }
  1784.   for (i=0;i<numtmplanes;i++)
  1785.     {
  1786.      SaveFile(tempname,MK_FP(TMinfo[i],0),fsize,tilemnum);
  1787.      fsize+=tilemnum;
  1788.     }
  1789.  
  1790.   MakeOBJ(tempname,outname,"_maphead",FARDATA,"MapHeader");
  1791. //  unlink(tempname);
  1792.  }
  1793.  
  1794.  RestoreBackground();
  1795.  SignalSound();
  1796.  
  1797.  //
  1798.  // FINSIHED. PRINT REPORT?
  1799.  //
  1800.  if (Message("Finished with compression.\n"
  1801.          "Print report on lengths?")==2)
  1802.  {
  1803.   fprintf(stdprn,"TED5 Carmacized Map Lengths for .%s\n\n",ext);
  1804.   fprintf(stdprn,"#\tMap Name\t\tLength\n");
  1805.   fprintf(stdprn,"_\t--------\t\t------\n");
  1806.   for (i=0;i<100;i++)
  1807.     if (MapFileHeader->dataoffsets[i]!=-1)
  1808.     {
  1809.      char tstr[16];
  1810.      strcpy(tstr,MapNames[i]);
  1811.      while(strlen(tstr)<16)
  1812.        strcat(tstr," ");
  1813.      fprintf(stdprn,"%d\t%s\t%d\n",i,tstr,maplengths[i]);
  1814.     }
  1815.   fprintf(stdprn,"%c",12);
  1816.  }
  1817.  
  1818.  LoadMap(whichmap);
  1819.  xbase=oxb;
  1820.  ybase=oyb;
  1821. }
  1822.  
  1823.  
  1824. ////////////////////////////////////////////////////
  1825. //
  1826. // Item - Change the LAUNCH name
  1827. //
  1828. ////////////////////////////////////////////////////
  1829. btype CLNb={"                                    ",1,5,1};
  1830. DialogDef CLNd={"Current LAUNCH name:\n\n\nNew LAUNCH name:",38,7,1,&CLNb,NULL};
  1831.  
  1832. void Item_LAUNCHname(void)
  1833. {
  1834.  char tempstr[40];
  1835.  
  1836.  
  1837.  MouseHide();
  1838.  DrawDialog(&CLNd,1);
  1839.  GetDialogXY(&CLNd,&sx,&sy);
  1840.  sy++;
  1841.  sx++;
  1842.  print(launchname);
  1843.  GetButtonXY(&CLNd,0,&sx,&sy);
  1844.  if (input(tempstr,36))
  1845.  {
  1846.   strcpy(launchname,tempstr);
  1847.   SaveTEDInfo();
  1848.  }
  1849.  MouseShow();
  1850.  RestoreBackground();
  1851. }
  1852.  
  1853.  
  1854. ////////////////////////////////////////////////////
  1855. //
  1856. // Item - Change the PARM string
  1857. //
  1858. ////////////////////////////////////////////////////
  1859. btype CPSb={"                                    ",1,5,1};
  1860. DialogDef CPSd={"Current PARM string:\n\n\nNew PARM string:",38,7,1,&CPSb,NULL};
  1861.  
  1862. void Item_PARMstring(void)
  1863. {
  1864.  char tempstr[40];
  1865.  
  1866.  
  1867.  MouseHide();
  1868.  DrawDialog(&CPSd,1);
  1869.  GetDialogXY(&CPSd,&sx,&sy);
  1870.  sy++;
  1871.  sx++;
  1872.  print(parmstring);
  1873.  GetButtonXY(&CPSd,0,&sx,&sy);
  1874.  if (input(tempstr,36))
  1875.  {
  1876.   strcpy(parmstring,tempstr);
  1877.   _fstrcpy(TEDInfo->parmstring,(char far *)parmstring);
  1878.   SaveTEDInfo();
  1879.  }
  1880.  MouseShow();
  1881.  RestoreBackground();
  1882. }
  1883.  
  1884.  
  1885. ////////////////////////////////////////////////////
  1886. //
  1887. // Item - Change Icon Rows
  1888. //
  1889. ////////////////////////////////////////////////////
  1890. btype CIRb={"    ",8,4,1};
  1891. DialogDef CIRd={"Enter amount of icons\n"
  1892.         "to add/delete.\n"
  1893.         "Use + or -.",22,6,1,&CIRb,NULL};
  1894.  
  1895. void Item_ChangeIconRows(void)
  1896. {
  1897.  unsigned i,j,dx,dy,max,oxbase,oybase,base;
  1898.  int value,owm;
  1899.  memptr block;
  1900.  
  1901.  
  1902.  if (!(MapFileHeader->maptype&IPLANE))
  1903.  {
  1904.   ErrDialog("You don't have an icon plane!"," OK ");
  1905.   return;
  1906.  }
  1907.  
  1908.  CheckForMapSave();
  1909.  
  1910.  oxbase=xbase;
  1911.  oybase=ybase;
  1912.  
  1913.  DrawDialog(&CIRd,1);
  1914.  GetButtonXY(&CIRd,0,&dx,&dy);
  1915.  sx=dx;
  1916.  sy=dy;
  1917.  MouseHide();
  1918.  value=inputint(3);
  1919.  MouseShow();
  1920.  if (!value || value==(int)ESCOUT)
  1921.  {
  1922.   RestoreBackground();
  1923.   return;
  1924.  }
  1925.  
  1926.  value=SGN(value)*(18*((abs(value)+17)/18));
  1927.  
  1928.  base=18*maxiconrows;
  1929.  maxiconrows+=value/18;
  1930.  MapFileHeader->NumIconRows+=value/18;
  1931.  
  1932.  owm=whichmap;
  1933.  RestoreBackground();
  1934.  
  1935.  
  1936.  //
  1937.  // MAKE SURE WE ADJUST TILEINFOM!
  1938.  //
  1939.  MMAllocate(&block,tilemnum+value);
  1940.  for (i=0;i<numtmplanes;i++)
  1941.  {
  1942.   _fmemset(block,0,tilemnum+value);
  1943.   movedata((unsigned)TMinfo[i],0,(unsigned)block,0,base);
  1944.   movedata((unsigned)TMinfo[i],base,
  1945.        (unsigned)block,base+value,tilemnum-base);
  1946.   MMFreePtr((memptr *)&TMinfo[i]);
  1947.   MMAllocate((memptr *)&TMinfo[i],tilemnum+value);
  1948.   movedata((unsigned)block,0,(unsigned)TMinfo[i],0,tilemnum+value);
  1949.  }
  1950.  MMFreePtr(&block);
  1951.  MapFileHeader->oldtilemnum=tilemnum+value;
  1952.  
  1953.  
  1954.  //
  1955.  // RUN THROUGH EACH MAP AND ADJUST TILEM VALUES
  1956.  //
  1957.  for (i=0;i<100;i++)
  1958.    if (MapFileHeader->dataoffsets[i]>=0)
  1959.      {
  1960.       whichmap=i;
  1961.       LoadMap(i);
  1962.       max=mapwidth*mapheight;
  1963.       for (j=0;j<max;j++)
  1964.     if (MapFrgnd[j]>0)
  1965.       MapFrgnd[j]+=value;
  1966.       DirtyFlag=1;
  1967.       SaveMap(0);
  1968.      }
  1969.  
  1970.  DirtyFlag=0;
  1971.  whichmap=owm;
  1972.  LoadMap(whichmap);
  1973.  xbase=oxbase;
  1974.  ybase=oybase;
  1975.  DrawMap();
  1976.  ErrDialog("If your map looks messed up,\n"
  1977.        "you need to change the amount\n"
  1978.        "of icons in your IGRAB script\n"
  1979.        "and re-grab your tiles!"," OK ");
  1980. }
  1981.  
  1982.  
  1983. ////////////////////////////////////////////////////
  1984. //
  1985. // Item - Change LAUNCH Icon
  1986. //
  1987. ////////////////////////////////////////////////////
  1988. void Item_ChangeLaunchIcon(void)
  1989. {
  1990.  sound(1700);
  1991.  TEDInfo->permicon=whichi-tilenum;
  1992.  delay(30);
  1993.  nosound();
  1994. }
  1995.  
  1996.  
  1997. ////////////////////////////////////////////////////
  1998. //
  1999. // Item - Change Background color
  2000. //
  2001. ////////////////////////////////////////////////////
  2002. btype CBCb[]={{"\xb",5,2,1},
  2003.           {"\xc",16,2,1},
  2004.           {"Exit",9,2,2}};
  2005. DialogDef CBCd={"Change Backgrnd Color!",22,4,3,&CBCb[0],0};
  2006. void Item_ChangeBkgndColor(void)
  2007. {
  2008.  int which;
  2009.  
  2010.  do
  2011.  {
  2012.   which=DoDialog(&CBCd);
  2013.   switch(which)
  2014.   {
  2015.    case 1:
  2016.      sound(1700);
  2017.      if (--BkgndColor<0)
  2018.        BkgndColor=15;
  2019.      TEDInfo->BackgndColor=BkgndColor;
  2020.      DrawMap();
  2021.      DrawInfoBar();
  2022.      break;
  2023.    case 2:
  2024.      sound(1700);
  2025.      if (++BkgndColor>15)
  2026.        BkgndColor=0;
  2027.      TEDInfo->BackgndColor=BkgndColor;
  2028.      DrawMap();
  2029.      DrawInfoBar();
  2030.   }
  2031.   nosound();
  2032.  } while(which>0 && which<3);
  2033. }
  2034.